package com.example.demo.system.service;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.servlet.http.HttpServletResponse;

import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.multipart.MultipartFile;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.demo.auth.dao.LoginDao;
import com.example.demo.core.DefineConstant;
import com.example.demo.entity.DictEntity;
import com.example.demo.entity.FileEntity;
import com.example.demo.entity.LoginEnity;
import com.example.demo.entity.LoginRole;
import com.example.demo.entity.MenuEntity;
import com.example.demo.entity.Organization;
import com.example.demo.entity.Person;
import com.example.demo.entity.base.PageRequestBean;
import com.example.demo.entity.base.PageResponseBean;
import com.example.demo.entity.base.ResponseEntity;
import com.example.demo.entity.base.TreeEntity;
import com.example.demo.entity.mybatisplus.TbSysLogin;
import com.example.demo.entity.mybatisplus.TbSysOrganization;
import com.example.demo.entity.mybatisplus.TbSysRole;
import com.example.demo.system.dao.SysLoginDao;
import com.example.demo.system.dao.SysOrgDao;
import com.example.demo.system.dao.SysRoleDao;
import com.example.demo.system.dao.SystemManageDao;
import com.example.demo.util.CommonUtil;
import com.example.demo.util.EmptyUtil;
import com.example.demo.util.EncryUtil;
import com.example.demo.util.FileUtils;
import com.example.demo.util.JWTUtil;
import com.example.demo.util.PrimaryKeyUtil;
import com.example.demo.util.PropertiesUtil;
import com.example.demo.util.RedisUtil;
import com.example.demo.util.RequestLoginCache;
import com.example.demo.util.ResponseFactory;
import com.example.demo.util.TreeUtil;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
@Transactional
public class SystemManageService {

	@Autowired
	private SystemManageDao systemManageDao;

	@Autowired
	private LoginDao loginDao;
	
	@Autowired
	private SysLoginDao sysLoginDao;

	@Autowired
	private RedisUtil redisUtil;

	@Autowired
	private Environment env;

	@Autowired
	private SqlSessionFactory sqlSessionFactory;
	
	@Autowired
	private SysRoleDao sysRoleDao;
	
	@Autowired
	private SysOrgDao sysOrgDao;

	/**
	 * @return
	 * @创建时间 2020年7月28日
	 * @创建人 许子文
	 * @功能描述: 刷新超级管理员的菜单权限
	 */
	public ResponseEntity<String> refreshSuperAuthor() {

		try {
			systemManageDao.refreshSuperAuthor();
		} catch (Exception e) {
			log.error("刷新超级管理员的权限失败", e);
			return ResponseFactory.setFail("刷新超级管理员的权限失败");
		}

		return ResponseFactory.setSuccess("超级管理员已获取所有菜单的权限");
	}

	/**
	 * @return
	 * @创建时间: 2019年12月18日
	 * @创建人: 许子文
	 * @功能描述: 修改个人信息
	 */
	public ResponseEntity<String> updatePersonInfo(String token, LoginEnity loginEntity) {

		if (EmptyUtil.isEmpty(token)) {
			log.error("未传入token");
			return ResponseFactory.setFail("未传入token");
		}

		if (EmptyUtil.isEmpty(loginEntity.getLogin_id())) {
			log.error("未传入登陆账号");
			return ResponseFactory.setFail("未传入登陆账号");
		}

		/*String loginInfoStr = null;
		
		try {
			loginInfoStr = redisUtil.getValue(token);
		} catch (Exception e) {
			log.error("从缓存中获取原个人信息失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("从缓存中获取原个人信息失败");
		}*/

		LoginEnity oldLoginInfo = RequestLoginCache.get();

		// 如果修改密码的话对密码进行校验
		if (EmptyUtil.isNotEmpty(loginEntity.getLogin_password())) {
			String old_password = loginEntity.getOld_password();

			String encryOldPwd = null;
			try {
				encryOldPwd = EncryUtil.encrypt(old_password, DefineConstant.ENCRYKEY);
			} catch (Exception e) {
				log.error("加密老密码失败", e);
				return ResponseFactory.setFail("加密老密码失败");
			}

			if (!encryOldPwd.equals(oldLoginInfo.getLogin_password())) {
				log.error("输入的原密码不正确");
				return ResponseFactory.setFail("输入的原密码不正确");
			}

			String encryPwd = null;

			try {
				encryPwd = EncryUtil.encrypt(loginEntity.getLogin_password(), DefineConstant.ENCRYKEY);
			} catch (Exception e) {
				log.error("加密新密码失败", e);
				return ResponseFactory.setFail("加密新密码失败");
			}

			loginEntity.setLogin_password(encryPwd);
			loginEntity.setLast_password(oldLoginInfo.getLogin_password());
		}

		try {
			systemManageDao.updateLoginInfo(loginEntity);
		} catch (Exception e) {
			log.error("修改用户登陆信息失败", e);
			return ResponseFactory.setFail("修改用户登陆信息失败");
		}

		Person person = loginEntity.getPerson();

		if (null == person) {
			return ResponseFactory.setFail("未传入用户个人信息");
		}

		try {
			systemManageDao.updatePersonInfo(person);
		} catch (Exception e) {
			log.error("修改用户个人信息失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("修改用户个人信息失败");
		}

		List<LoginRole> roles = oldLoginInfo.getLogin_roles();

		List<LoginEnity> newLoginList = null;

		try {
			newLoginList = loginDao.verifiyLogin(loginEntity);
		} catch (Exception e) {
			log.error("获取新的登陆信息失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("获取新的登陆信息失败");
		}

		if (EmptyUtil.isEmpty(newLoginList)) {
			log.error("获取不到登陆信息");
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("获取不到登陆信息");
		}

		LoginEnity newLoginInfo = newLoginList.get(0);

		newLoginInfo.setLogin_roles(roles);

		String newLoginInfoStr = JSONObject.toJSONString(newLoginInfo);

		try {
//			redisUtil.addString(token, newLoginInfoStr, Long.parseLong(PropertiesUtil.getProperty("tokenTimeOut")));
			redisUtil.setToken(token, newLoginInfoStr, Long.parseLong(PropertiesUtil.getProperty("tokenTimeOut")));
		} catch (NumberFormatException e) {
			log.error("超时时间转换异常", e);
			TransactionAspectSupport.currentTransactionStatus().isRollbackOnly();
			return ResponseFactory.setFail("超时时间转换异常");
		} catch (Exception e) {
			log.error("将更新后的个人信息保存至redis失败", e);
			TransactionAspectSupport.currentTransactionStatus().isRollbackOnly();
			return ResponseFactory.setFail("将更新后的个人信息保存至redis失败");
		}

		return ResponseFactory.setSuccess("修改个人信息成功!");
	}

	/**
	 * @return
	 * @创建时间: 2019年11月27日
	 * @创建人: 许子文
	 * @功能描述: 删除菜单
	 */
	public ResponseEntity<String> deleteMenu(String menu_id) {

		// 检验有没有子菜单
		MenuEntity pId = new MenuEntity();

		pId.setParent_id(menu_id);

		List<MenuEntity> childs = null;

		try {
			childs = systemManageDao.queryMenuList(pId);
		} catch (Exception e) {
			log.error("获取此菜单下子菜单失败", e);
			return ResponseFactory.setFail("获取此菜单下子菜单失败");
		}

		if (EmptyUtil.isNotEmpty(childs)) {
			log.info("此菜单下有子菜单");
			return ResponseFactory.setFail("请先删除此菜单下所有子菜单再对此菜单进行删除");
		}

		MenuEntity menuEntity = new MenuEntity();

		menuEntity.setMenu_id(menu_id);

		try {
			systemManageDao.deleteRoleMenuRelation(menuEntity);
		} catch (Exception e) {
			log.error("删除角色与菜单关联关系失败", e);
			return ResponseFactory.setFail("删除角色与菜单关联关系失败");
		}

		try {
			systemManageDao.deleteMenu(menu_id);
		} catch (Exception e) {
			log.error("删除菜单失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("删除菜单失败");
		}

		// 刷新redis数据
		try {
			refreshMenuCache();
		} catch (Exception e) {
			log.error("刷新缓存中菜单数据失败", e);
			TransactionAspectSupport.currentTransactionStatus().isRollbackOnly();
			return ResponseFactory.setFail("刷新缓存中菜单数据失败");
		}

		return ResponseFactory.setSuccess("删除菜单成功");
	}

	/**
	 * @param isRecord 
	 * @return
	 * @创建时间: 2019年11月23日
	 * @创建人: 许子文
	 * @功能描述: 上传文件
	 */
	public ResponseEntity<FileEntity> uploadFile(MultipartFile file, String relation_id, String file_type,
			String token, Boolean isRecord) {

		if (EmptyUtil.isEmpty(token)) {
			log.error("未获取token");
			return ResponseFactory.setFail("未获取token");
		}

		String upload_user = null;

		try {
			upload_user = JWTUtil.getLoginId(token);
		} catch (Exception e) {
			log.error("获取登陆人id失败", e);
			return ResponseFactory.setFail("获取登陆人id失败");
		}

		if (null == file) {
			log.error("未传入文件");
			return ResponseFactory.setFail("未传入文件");
		}

		if (EmptyUtil.isEmpty(file_type)) {
			log.error("未传入文件类型");
			return ResponseFactory.setFail("未传入文件类型");
		}

		String uploadFilePath = PropertiesUtil.getProperty("imagepath");

		boolean createSuccessed = FileUtils.createDirectory(uploadFilePath);

		if (!createSuccessed) {
			log.error("创建文件夹失败");
			return ResponseFactory.setFail("创建文件夹失败");
		}

		String file_name = file.getOriginalFilename();

		// 文件格式分割符位置
		int lastpoint = file_name.lastIndexOf(".");

		// 文件格式
		String file_format = file_name.substring(lastpoint);

		String serverFileName = PrimaryKeyUtil.getUUIDWithOutLink();

		String serverFilePath = null;

		if (uploadFilePath.endsWith(File.separator)) {
			serverFilePath = uploadFilePath + serverFileName + file_format;
		} else {
			serverFilePath = uploadFilePath + File.separator + serverFileName + file_format;
		}

		String fileUrl = PropertiesUtil.getProperty("fileUrl");

		String serverFileUrl = null;

		String serverContextPath = env.getProperty("server.servlet.context-path");

		if (fileUrl.endsWith("/")) {
			serverFileUrl = serverContextPath + fileUrl + serverFileName + file_format;
		} else {
			serverFileUrl = serverContextPath + fileUrl + "/" + serverFileName + file_format;
		}

		try {
			file.transferTo(new File(serverFilePath));
		} catch (IllegalStateException | IOException e) {
			log.error("上传文件失败", e);
			return ResponseFactory.setFail("上传文件失败");
		}

		FileEntity fileEntity = new FileEntity();

		fileEntity.setFile_id(serverFileName);
		fileEntity.setFile_name(file_name);
		fileEntity.setFile_format(file_format);
		fileEntity.setFile_path(serverFilePath);
		fileEntity.setFile_url(serverFileUrl);
		fileEntity.setFile_type(file_type);
		fileEntity.setUpload_user(upload_user);
		fileEntity.setRelation_id(relation_id);

		if(isRecord) {
			try {
				systemManageDao.recordFileInfo(fileEntity);
			} catch (Exception e) {
				log.error("记录上传文件信息失败", e);
				return ResponseFactory.setFail("记录上传文件信息失败");
			}
		}

		log.info("上传文件成功!,{}", fileEntity);
		return ResponseFactory.setSuccess(fileEntity, "上传文件成功!");
	}

	/**
	 * @return
	 * @创建时间: 2019年11月21日
	 * @创建人: 许子文
	 * @功能描述: 重置用户密码
	 */
	public ResponseEntity<String> resetPassword(String login_id) {

		String initialPWD = PropertiesUtil.getProperty("initialPWD");

		String encryPWD;
		try {
			encryPWD = EncryUtil.encrypt(initialPWD, DefineConstant.ENCRYKEY);
		} catch (Exception e) {
			log.error("加密密码失败", e);
			return ResponseFactory.setFail("加密密码失败");
		}

		LoginEnity loginEntity = new LoginEnity();

		loginEntity.setLogin_id(login_id);
		loginEntity.setLogin_password(encryPWD);

		try {
			systemManageDao.updateLoginInfo(loginEntity);
		} catch (Exception e) {
			log.error("重置密码失败", e);
			return ResponseFactory.setFail("重置密码失败");
		}

		return ResponseFactory.setSuccess("账号" + login_id + "的密码已重置为：" + initialPWD);
	}

	/**
	 * @return
	 * @创建时间: 2019年11月18日
	 * @创建人: 许子文
	 * @功能描述: 获取角色关联菜单
	 */
	public ResponseEntity<String> getRoleMenuRelation(String role_id) {
		ResponseEntity<String> ret = new ResponseEntity<>();

		List<String> roleMenus = null;

		try {
			roleMenus = systemManageDao.getRoleMenuRelation(role_id);
		} catch (Exception e) {
			log.error("获取角色关联菜单失败", e);
			return ResponseFactory.setFail("获取角色关联菜单失败");
		}

		return ret.setList(roleMenus);
	}

	/**
	 * @return
	 * @创建时间: 2019年11月18日
	 * @创建人: 许子文
	 * @功能描述: 修改角色信息
	 */
	public ResponseEntity<String> updateRole(LoginRole loginRole) {

		String role_id = loginRole.getRole_id();

		if (EmptyUtil.isEmpty(role_id)) {
			return ResponseFactory.setFail("未传入角色索引");
		}

		try {
			systemManageDao.updateRole(loginRole);
		} catch (Exception e) {
			log.error("修改角色信息失败", e);
			return ResponseFactory.setFail("修改角色信息失败");
		}

		List<MenuEntity> menus = loginRole.getMenus();

		if (EmptyUtil.isNotEmpty(menus)) {

			try {
				MenuEntity menuEntity = new MenuEntity();
				menuEntity.setRole_id(role_id);
				systemManageDao.deleteRoleMenuRelation(menuEntity);
			} catch (Exception e) {
				log.error("删除原有的角色、菜单关系失败", e);
				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
				return ResponseFactory.setFail("删除原有的角色、菜单关系失败");
			}

			SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH,false);

			SystemManageDao batchSMD = sqlSession.getMapper(SystemManageDao.class);

			int menuLen = menus.size();

			for (int i = 0; i < menuLen; i++) {
				String menu_id = menus.get(i).getMenu_id();

				batchSMD.setRoleMenuRelation(role_id, menu_id);
			}

			try {
				sqlSession.commit();
				sqlSession.clearCache();
			} catch (Exception e) {
				log.error("重新建立角色与菜单的关系失败", e);
				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
				return ResponseFactory.setFail("重新建立角色与菜单的关系失败");
			}
		}

		return ResponseFactory.setSuccess("修改角色成功");
	}

	/**
	 * @return
	 * @创建时间: 2019年11月18日
	 * @创建人: 许子文
	 * @功能描述: 删除角色信息
	 */
	public ResponseEntity<String> deleteRole(String role_id) {

		if (EmptyUtil.isEmpty(role_id)) {
			return ResponseFactory.setFail("未传入角色索引");
		}

		LoginEnity loginEntity = new LoginEnity();

		loginEntity.setRole_id(role_id);

		List<LoginEnity> logins = null;

		try {
			logins = systemManageDao.queryLoginList(loginEntity);
		} catch (Exception e) {
			log.error("验证是否用用户使用该角色失败", e);
			return ResponseFactory.setFail("验证是否用用户使用该角色失败");
		}

		if (EmptyUtil.isNotEmpty(logins)) {
			return ResponseFactory.setFail("有用户使用该角色,无法删除!");
		}

		try {
			systemManageDao.deleteRole(role_id);
		} catch (Exception e) {
			log.error("删除角色信息失败", e);
			return ResponseFactory.setFail("删除角色信息失败");
		}

		try {
			MenuEntity menuEntity = new MenuEntity();
			menuEntity.setRole_id(role_id);
			systemManageDao.deleteRoleMenuRelation(menuEntity);
		} catch (Exception e) {
			log.error("删除角色与菜单关联关系失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("删除角色与菜单关联关系失败");
		}

		return ResponseFactory.setSuccess("删除角色成功");
	}

	/**
	 * @return
	 * @创建时间: 2019年11月18日
	 * @创建人: 许子文
	 * @功能描述: 保存角色
	 */
	public ResponseEntity<String> addRole(LoginRole loginRole) {
		
		String role_name = loginRole.getRole_name();
		
		String role_code = loginRole.getRole_code();
		
		if(EmptyUtil.isEmpty(role_name)){
			return ResponseFactory.setFail("未填写角色名称");
		}
		
		if(EmptyUtil.isEmpty(role_code)){
			return ResponseFactory.setFail("未填写角色编码");
		}
		
		QueryWrapper<TbSysRole> wrapper = new QueryWrapper<>();
		
		wrapper.eq("role_name",role_name).or().eq("role_code",role_code);
		
		Long dataNum = sysRoleDao.selectCount(wrapper);
		
		if(dataNum>0L){
			return ResponseFactory.setFail("角色名称或角色编码重复，请重新填写");
		}

		String role_id = PrimaryKeyUtil.getUUIDWithOutLink();

		loginRole.setRole_id(role_id);

		try {
			systemManageDao.addRole(loginRole);
		} catch (Exception e) {
			log.error("添加新角色失败", e);
			return ResponseFactory.setFail("添加新角色失败");
		}

		List<MenuEntity> menus = loginRole.getMenus();

		if (EmptyUtil.isNotEmpty(menus)) {
			//通过mybatis的批量操作插入角色和菜单的关联数据
			SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH,false);

			SystemManageDao batchSMD = sqlSession.getMapper(SystemManageDao.class);

			int menuLen = menus.size();

			for (int i = 0; i < menuLen; i++) {
				String menu_id = menus.get(i).getMenu_id();

				batchSMD.setRoleMenuRelation(role_id, menu_id);
			}

			try {
				sqlSession.commit();
				sqlSession.clearCache();
			} catch (Exception e) {
				log.error("建立角色与菜单的关系失败", e);
				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
				return ResponseFactory.setFail("建立角色与菜单的关系失败");
			}
		}

		return ResponseFactory.setSuccess("添加角色成功");
	}

	/**
	 * @return
	 * @创建时间: 2019年11月23日
	 * @创建人: 许子文
	 * @功能描述: 将组织机构数据保存到缓存中去
	 */
	public ResponseEntity<Map<String, Object>> getOrgTree() {
		ResponseEntity<Map<String, Object>> ret = new ResponseEntity<>();

		String parent_id = "0";

		List<Map<String, Object>> orgTree = null;

		try {
			orgTree = getOrgTreeList(parent_id);
		} catch (Exception e) {
			log.error("获取组织机构树失败", e);
			return ResponseFactory.setFail("获取组织机构树失败");
		}

		return ret.setList(orgTree);
	}

	/**
	 * @return
	 * @创建时间: 2019年11月16日
	 * @创建人: 许子文
	 * @功能描述: 获取菜单树
	 */
	public ResponseEntity<TreeEntity> getMenuTree() {
		ResponseEntity<TreeEntity> ret = new ResponseEntity<>();

		List<TreeEntity> menuTree = null;

		try {
			menuTree = getTreeList();
		} catch (Exception e) {
			log.error("获取菜单树失败", e);
			return ResponseFactory.setFail("获取菜单树失败");
		}

		return ret.setList(menuTree);
	}

	/**
	 * @return
	 * @创建时间: 2019年11月23日
	 * @创建人: 许子文
	 * @功能描述: 通过递归算法获取组织机构
	 */
	public List<Map<String, Object>> getOrgTreeList(String parent_id) throws Exception {
		List<Map<String, Object>> orgTree = new ArrayList<>();
		
		List<Organization> orgList = systemManageDao.queryOrgList(new Organization());

		if(EmptyUtil.isEmpty(orgList)) {
			return orgTree;
		}
		
		for (Organization organization : orgList) {
			Map<String, Object> treeEntity = new HashMap<>();
			treeEntity.put("id", organization.getOrgid());
			treeEntity.put("parentId", organization.getParent_id());
			treeEntity.put("title", organization.getOrgname());
			treeEntity.put("org_type", organization.getOrg_type());
			treeEntity.put("children", new ArrayList<>());
			orgTree.add(treeEntity);
		}
		
		orgTree = TreeUtil.installOrgTree(orgTree);
		
		return orgTree;
	}

	/**
	 * @return
	 * @创建时间: 2019年11月16日
	 * @创建人: 许子文
	 * @功能描述: 通过递归算法获取菜单树
	 */
	public List<TreeEntity> getTreeList() throws Exception {
		List<TreeEntity> menuTree = new ArrayList<>();

		List<MenuEntity> allMenuList = systemManageDao.queryMenuList(new MenuEntity());
		
		if(EmptyUtil.isEmpty(allMenuList)) {
			return menuTree;
		}
		
		for (MenuEntity menuEntity : allMenuList) {
			TreeEntity treeEntity = new TreeEntity();
			treeEntity.setId(menuEntity.getMenu_id());
			treeEntity.setTitle(menuEntity.getMenu_name());
			treeEntity.setParentId(menuEntity.getParent_id());;
			treeEntity.setChildren(new ArrayList<>());
			menuTree.add(treeEntity);
		}
		
		menuTree = TreeUtil.installCommonTree(menuTree);

		return menuTree;
	}

	/**
	 * @return
	 * @创建时间: 2019年11月14日
	 * @创建人: 许子文
	 * @功能描述: 修改用户信息
	 */
	public ResponseEntity<String> updateUser(LoginEnity loginEntity) {

		if (EmptyUtil.isEmpty(loginEntity.getLogin_id())) {
			return ResponseFactory.setFail("未传入登陆账号");
		}

		try {
			systemManageDao.updateLoginInfo(loginEntity);
		} catch (Exception e) {
			log.error("修改用户登陆信息失败", e);
			return ResponseFactory.setFail("修改用户登陆信息失败");
		}

		Person person = loginEntity.getPerson();

		if (null == person) {
			return ResponseFactory.setFail("未传入用户个人信息");
		}

		try {
			systemManageDao.updatePersonInfo(person);
		} catch (Exception e) {
			log.error("修改用户个人信息失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("修改用户个人信息失败");
		}

		try {
			systemManageDao.deleteRoleInfo(loginEntity.getLogin_id());
		} catch (Exception e) {
			log.error("删除用户角色信息失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("删除用户角色信息失败");
		}

		List<LoginRole> login_roles = loginEntity.getLogin_roles();

		if (EmptyUtil.isEmpty(login_roles)) {
			return ResponseFactory.setFail("未传入用户角色");
		}

		int rolelen = login_roles.size();

		try {
			for (int i = 0; i < rolelen; i++) {
				LoginRole loginRole = login_roles.get(i);

				loginRole.setLogin_id(loginEntity.getLogin_id());

				systemManageDao.addUserRole(loginRole);
			}
		} catch (Exception e) {
			log.error("更改用户角色失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("更改用户角色失败");
		}

		return ResponseFactory.setSuccess("修改用户信息成功!");
	}

	/**
	 * @return
	 * @创建时间: 2019年11月13日
	 * @创建人: 许子文
	 * @功能描述: 删除用户
	 */
	public ResponseEntity<String> deleteUser(String login_id, String token) {

		if (EmptyUtil.isEmpty(login_id)) {
			return ResponseFactory.setFail("未传入账号!");
		}

		String now_login;

		try {
			now_login = JWTUtil.getLoginId(token);
		} catch (Exception e) {
			log.error("通过token解析登陆账号失败", e);
			return ResponseFactory.setFail("通过token解析登陆账号失败");
		}

		if (now_login.equals(login_id)) {
			return ResponseFactory.setFail("不允许删除自己的账号!");
		}

		try {
			systemManageDao.deleteRoleInfo(login_id);
		} catch (Exception e) {
			log.error("删除用户角色信息失败", e);
			return ResponseFactory.setFail("删除用户角色信息失败");
		}

		try {
			systemManageDao.deletePersonInfo(login_id);
		} catch (Exception e) {
			log.error("删除用户个人信息失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("删除用户个人信息失败");
		}

		try {
			systemManageDao.deleteLoginInfo(login_id);
		} catch (Exception e) {
			log.error("删除用户登陆信息失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("删除用户登陆信息失败");
		}

		return ResponseFactory.setSuccess("删除用户成功!");
	}

	/**
	 * @return
	 * @创建时间: 2019年11月13日
	 * @创建人: 许子文
	 * @功能描述: 添加用户
	 */
	public ResponseEntity<String> addUser(LoginEnity loginEntity) {

		Person person = loginEntity.getPerson();

		if (null == person) {
			person = new Person();
		}

		List<LoginRole> login_roles = loginEntity.getLogin_roles();

		if (EmptyUtil.isEmpty(loginEntity.getLogin_id())) {
			return ResponseFactory.setFail("未传入用户账号");
		}

		if (EmptyUtil.isEmpty(loginEntity.getLogin_password())) {
			return ResponseFactory.setFail("未传入密码");
		}

		if (EmptyUtil.isEmpty(person.getPerson_name())) {
			return ResponseFactory.setFail("未传入用户姓名");
		}

		if (EmptyUtil.isEmpty(person.getPhone_no())) {
			return ResponseFactory.setFail("未传入用户手机号码");
		}

		if (EmptyUtil.isEmpty(login_roles)) {
			return ResponseFactory.setFail("未传入用户角色");
		}
		
		QueryWrapper<TbSysLogin> wrapper = new QueryWrapper<>();
		wrapper.eq("login_id", loginEntity.getLogin_id());
		Long loginNum = sysLoginDao.selectCount(wrapper);
		if(null != loginNum && loginNum > 0L) {
			return ResponseFactory.setFail("此账号已存在!");
		}
		
		// person_id与login_id保持一致
//		String person_id = PrimaryKeyUtil.getUUIDWithOutLink();

		loginEntity.setPerson_id(loginEntity.getLogin_id());

		String encry_pwd = null;

		try {
			encry_pwd = EncryUtil.encrypt(loginEntity.getLogin_password(), DefineConstant.ENCRYKEY);
		} catch (Exception e) {
			log.error("加密密码失败", e);
			return ResponseFactory.setFail("加密密码失败");
		}

		loginEntity.setLogin_password(encry_pwd);

		try {
			systemManageDao.addUserLogin(loginEntity);
		} catch (Exception e) {
			log.error("向登陆表添加用户信息失败", e);
			return ResponseFactory.setFail("向登陆表添加用户信息失败");
		}

		person.setPerson_id(loginEntity.getLogin_id());

		try {
			systemManageDao.addUserPerson(person);
		} catch (Exception e) {
			log.error("向人员表添加用户信息失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("向人员表添加用户信息失败");
		}

		int rolelen = login_roles.size();

		try {
			for (int i = 0; i < rolelen; i++) {
				LoginRole loginRole = login_roles.get(i);

				loginRole.setLogin_id(loginEntity.getLogin_id());

				systemManageDao.addUserRole(loginRole);
			}
		} catch (Exception e) {
			log.error("记录用户角色失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("记录用户角色失败");
		}

		return ResponseFactory.setSuccess("添加用户成功!");
	}

	public ResponseEntity<PageResponseBean<LoginRole>> queryRolesForPage(PageRequestBean<LoginRole> pagerequest) {

		LoginRole loginRole = pagerequest.getParams();

		int pageNum = pagerequest.getPageNum();
		int pageSize = pagerequest.getPageSize();

		Page<LoginRole> page = PageHelper.startPage(pageNum, pageSize, true);

		List<LoginRole> roles = null;

		try {
			roles = systemManageDao.getAllRoles(loginRole);
		} catch (Exception e) {
			log.error("获取角色信息失败", e);
			return ResponseFactory.setFail("获取角色信息失败");
		}

		long total = page.getTotal();

		int totalPages;

		try {
			totalPages = CommonUtil.getTotalPages(pageSize, total);
		} catch (Exception e) {
			log.error("获取总页数时失败", e);
			return ResponseFactory.setFail("获取总页数时失败");
		}

		PageResponseBean<LoginRole> pageresp = new PageResponseBean<>(total, pageSize, pageNum, totalPages, roles);

		return ResponseFactory.setObject(pageresp);
	}

	/**
	 * @return
	 * @创建时间: 2019年11月12日
	 * @创建人: 许子文
	 * @功能描述: 获取用户角色
	 */
	public ResponseEntity<LoginRole> getAllRoles(LoginRole loginRole) {
		ResponseEntity<LoginRole> ret = new ResponseEntity<>();

		List<LoginRole> roles = null;

		try {
			roles = systemManageDao.getAllRoles(loginRole);
		} catch (Exception e) {
			log.error("获取用户角色失败", e);
			return ResponseFactory.setFail("获取用户角色失败");
		}

		// 过滤掉超级管理员的角色(暂时在sql里过滤)
		/*
		 * if(EmptyUtil.isNotEmpty(roles)) { int roleLen = roles.size(); for (int i = 0;
		 * i < roleLen; i++) { if("0".equals(roles.get(i).getRole_id())) {
		 * roles.remove(i); break; } } }
		 */

		return ret.setList(roles);
	}

	/**
	 * @return
	 * @创建时间: 2019年10月15日
	 * @创建人: 许子文
	 * @功能描述: 查询用户列表
	 */
	public ResponseEntity<PageResponseBean<LoginEnity>> queryLoginList(PageRequestBean<LoginEnity> pagerequest) {

		LoginEnity loginEntity = pagerequest.getParams();

		if (EmptyUtil.isNotEmpty(loginEntity.getRoleIds())) {
			String roleIds;
			try {
				roleIds = CommonUtil.addSingleton(loginEntity.getRoleIds());
			} catch (Exception e) {
				log.error("给角色id加单引号时异常", e);
				return ResponseFactory.setFail("给角色id加单引号时异常");
			}

			loginEntity.setRoleIds(roleIds);
		}

		int pageNum = pagerequest.getPageNum();

		int pageSize = pagerequest.getPageSize();

		Page<LoginEnity> page = PageHelper.startPage(pageNum, pageSize, true);

		List<LoginEnity> logins = null;

		try {
			logins = systemManageDao.queryLoginList(loginEntity);
		} catch (Exception e) {
			log.error("获取菜单列表失败", e);
			return ResponseFactory.setFail("获取菜单列表失败");
		}

		long total = page.getTotal();

		int totalPages;

		try {
			totalPages = CommonUtil.getTotalPages(pageSize, total);
		} catch (Exception e) {
			log.error("获取总页数时失败", e);
			return ResponseFactory.setFail("获取总页数时失败");
		}

		PageResponseBean<LoginEnity> pageResp = new PageResponseBean<>(total, pageSize, pageNum, totalPages, logins);

		return ResponseFactory.setObject(pageResp);
	}

	/**
	 * @return
	 * @创建时间: 2019年11月21日
	 * @创建人: 许子文
	 * @功能描述: 添加菜单
	 */
	public ResponseEntity<String> addMenu(MenuEntity menuEntity) {

		if (null == menuEntity) {
			return ResponseFactory.setFail("未传入菜单属性");
		}

		if (EmptyUtil.isEmpty(menuEntity.getParent_id())) {
			menuEntity.setParent_id("0");
		}

		String menu_id = PrimaryKeyUtil.getUUIDWithOutLink();

		menuEntity.setMenu_id(menu_id);

		try {
			systemManageDao.addMenu(menuEntity);
		} catch (Exception e) {
			log.error("添加菜单失败", e);
			return ResponseFactory.setFail("添加菜单失败");
		}

		// 刷新redis数据
		try {
			refreshMenuCache();
		} catch (Exception e) {
			log.error("刷新缓存中菜单数据失败", e);
			TransactionAspectSupport.currentTransactionStatus().isRollbackOnly();
			return ResponseFactory.setFail("刷新缓存中菜单数据失败");
		}

		return ResponseFactory.setSuccess("添加菜单成功");
	}

	/**
	 * @param menuEntity
	 * @return
	 * @创建时间: 2019年9月14日
	 * @创建人: 许子文
	 * @功能描述: 查询所有菜单
	 */
	public ResponseEntity<MenuEntity> queryMenuList(MenuEntity menuEntity) {
		ResponseEntity<MenuEntity> ret = new ResponseEntity<>();

		List<MenuEntity> menus = null;

		try {
			menus = systemManageDao.queryMenuList(menuEntity);
		} catch (Exception e) {
			log.error("查询菜单列表失败", e);
			ret.setList(new ArrayList<>());
			ResponseFactory.setFail("查询菜单列表失败");
			return ret;
		}

		// 将根节点的parent_id置为0,否则前端树状列表无法正确展示
		if (EmptyUtil.isNotEmpty(menus)) {
			int menuNum = menus.size();

			Map<String, Integer> idsMap = new HashMap<>();

			for (int i = 0; i < menuNum; i++) {
				MenuEntity menu = menus.get(i);

				String menuId = menu.getMenu_id();

				Integer idNum = idsMap.get(menuId);

				if (null == idNum) {
					idNum = 0;
				}

				idsMap.put(menuId, ++idNum);
			}

			for (int i = 0; i < menuNum; i++) {
				MenuEntity menu = menus.get(i);

				String menuPid = menu.getParent_id();

				if (null == idsMap.get(menuPid)) {
					menu.setParent_id("0");
				}
			}
		}

		ret.setList(menus);

		return ret;
	}

	/**
	 * @return
	 * @创建时间: 2020年1月7日
	 * @创建人: 许子文
	 * @功能描述: 查询所有的组织机构
	 */
	public ResponseEntity<Organization> queryOrgList(Organization organization) {
		ResponseEntity<Organization> ret = new ResponseEntity<>();

		List<Organization> orgs = null;

		try {
			orgs = systemManageDao.queryOrgList(organization);
		} catch (Exception e) {
			log.error("获取组织机构列表失败", e);
			ret.setList(new ArrayList<>());
			return ResponseFactory.setFail("获取组织机构列表失败");
		}

		// 把根节点的parent_id置为0,否则前端树状表格无法展示
		if (EmptyUtil.isNotEmpty(orgs)) {
			int orgNums = orgs.size();

			Map<String, Integer> idsMap = new HashMap<>();

			for (int i = 0; i < orgNums; i++) {
				Organization org = orgs.get(i);

				String orgId = org.getOrgid();

				Integer idNum = idsMap.get(orgId);

				if (null == idNum) {
					idNum = 0;
				}

				idsMap.put(orgId, ++idNum);
			}

			for (int i = 0; i < orgNums; i++) {
				Organization org = orgs.get(i);

				String pOrgId = org.getParent_id();

				Integer idNum = idsMap.get(pOrgId);

				if (null == idNum) {
					org.setParent_id("0");
				}
			}
		}

		return ret.setList(orgs);
	}

	/**
	 * @return
	 * @创建时间: 2020年1月8日
	 * @创建人: 许子文
	 * @功能描述: 修改菜单信息
	 */
	public ResponseEntity<String> updateMenu(MenuEntity menuEntity) {

		if (null == menuEntity || EmptyUtil.isEmpty(menuEntity.getMenu_id())) {
			log.error("传入的菜单信息为空或菜单id未传递");
			return ResponseFactory.setFail("传入的菜单信息为空或菜单id未传递");
		}

		try {
			systemManageDao.updateMenu(menuEntity);
		} catch (Exception e) {
			log.error("修改菜单信息失败", e);
			return ResponseFactory.setFail("修改菜单信息失败");
		}

		// 刷新redis数据
		try {
			refreshMenuCache();
		} catch (Exception e) {
			log.error("刷新缓存中菜单数据失败", e);
			TransactionAspectSupport.currentTransactionStatus().isRollbackOnly();
			return ResponseFactory.setFail("刷新缓存中菜单数据失败");
		}

		return ResponseFactory.setSuccess("修改菜单信息成功!");
	}

	/**
	 * @return
	 * @创建时间: 2020年1月20日
	 * @创建人: 许子文
	 * @功能描述: 删除组织机构
	 */
	public ResponseEntity<String> deleteOrg(Organization organization) {

		if (null == organization || EmptyUtil.isEmpty(organization.getOrgid())) {
			log.error("未传入组织机构id");
			return ResponseFactory.setFail("未传入组织机构id");
		}

		String rootOrgId = organization.getOrgid();

		try {
			recurisionDeleteOrg(rootOrgId);
		} catch (Exception e) {
			log.error("递归删除组织机构失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("递归删除组织机构失败");
		}

		// 刷新redis数据
		try {
			refreshOrgCache();
		} catch (Exception e) {
			log.error("刷新redis中的组织机构数据失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("刷新redis中的组织机构数据失败");
		}

		return ResponseFactory.setSuccess("删除组织机构【" + organization.getOrgname() + "】及其子区域成功");
	}

	/**
	 * @return
	 * @创建时间: 2020年1月20日
	 * @创建人: 许子文
	 * @功能描述: 递归删除组织机构
	 */
	public void recurisionDeleteOrg(String rootOrgId) throws Exception {
		Organization pOrg = new Organization();

		pOrg.setParent_id(rootOrgId);

		List<Organization> childOrgs = systemManageDao.queryOrgList(pOrg);

		if (EmptyUtil.isNotEmpty(childOrgs)) {
			int childLen = childOrgs.size();

			for (int i = 0; i < childLen; i++) {
				Organization child = childOrgs.get(i);

				String childOrgId = child.getOrgid();

				recurisionDeleteOrg(childOrgId);
			}
		}

		Organization selfOrg = new Organization();
		selfOrg.setOrgid(rootOrgId);
		systemManageDao.deleteOrg(selfOrg);
	}

	/**
	 * @return
	 * @创建时间: 2020年1月20日
	 * @创建人: 许子文
	 * @功能描述: 添加组织机构
	 */
	public ResponseEntity<String> addOrg(Organization organization) {

		if (null == organization) {
			log.error("未传入组织机构属性");
			return ResponseFactory.setFail("未传入组织机构属性");
		}

		/*if (EmptyUtil.isEmpty(organization.getOrgid())) {
			log.error("未传入组织机构编码");
			return ResponseFactory.setFail("未传入组织机构编码");
		}*/

		if (EmptyUtil.isEmpty(organization.getOrgname())) {
			log.error("未传入组织机构名称");
			return ResponseFactory.setFail("未传入组织机构名称");
		}

		if (EmptyUtil.isEmpty(organization.getParent_id())) {
			log.info("未传入父级组织机构编码,设置为根节点组织机构");
			organization.setParent_id("0");
		}
		if(EmptyUtil.isEmpty(organization.getOrgid())) {
			organization.setOrgid(genrateOrgCode(organization.getParent_id()));
		}

		try {
			systemManageDao.addOrg(organization);
		} catch (Exception e) {
			log.error("添加组织机构失败", e);
			return ResponseFactory.setFail("添加组织机构失败");
		}

		// 刷新redis数据
		try {
			refreshOrgCache();
		} catch (Exception e) {
			log.error("刷新redis中的组织机构数据失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("刷新redis中的组织机构数据失败");
		}

		return ResponseFactory.setSuccess("添加组织机构成功!");
	}
	
	/**
	 * 生成组织机构编码
	 * @创建者 xzw
	 * @创建日期 2025年5月15日
	 * @返回类型 String
	 * @功能描述 自动生成组织机构编码，最顶层的编码为01-99，每下一级就在顶层编码的后面加两位，范围也是01-99，超过范围则不继续新增
	 *
	 */
	public String genrateOrgCode(String parentId) {
		
		String lockKey = DefineConstant.REDIS_LOCK_PRE+"org:"+parentId;
		
		try {
			redisUtil.getLock(lockKey, 5L, 3L);
			
			LambdaQueryWrapper<TbSysOrganization> qw = new LambdaQueryWrapper<>();
			qw.eq(TbSysOrganization::getParent_id, parentId);
			qw.orderByDesc(TbSysOrganization::getOrgid);
			qw.last(" LIMIT 1");
			
			TbSysOrganization maxOrg = sysOrgDao.selectOne(qw);
			
			String nextCode = null;
			
			if(null==maxOrg) {
				
				nextCode = "01";
				
			} else {
				
				String nowCode = maxOrg.getOrgid();
				
				
				if(!"0".equals(parentId)) {
					nowCode = nowCode.substring(parentId.length());
				}
				
				Integer codeNumber = Integer.parseInt(nowCode)+1;
				
				nextCode = String.format("%02d", codeNumber);
				
			}
			return "0".equals(parentId)?nextCode:(parentId+nextCode);
			
		} catch (Exception e) {
			log.error("生成组织机构编码失败",e);
			return null;
		} finally {
			redisUtil.unLock(lockKey);
		}
	}

	/**
	 * @return
	 * @创建时间: 2020年1月27日
	 * @创建人: 许子文
	 * @功能描述: 修改组织机构
	 */
	public ResponseEntity<String> updateOrg(Organization organiztion) {

		if (null == organiztion || EmptyUtil.isEmpty(organiztion.getOrgid())) {
			return ResponseFactory.setFail("未传入组织机构id");
		}

		try {
			systemManageDao.updateOrg(organiztion);
		} catch (Exception e) {
			log.error("修改组织机构失败", e);
			return ResponseFactory.setFail("修改组织机构失败");
		}

		try {
			refreshOrgCache();
		} catch (Exception e) {
			log.error("刷新redis中的组织机构数据失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("刷新redis中的组织机构数据失败");
		}

		return ResponseFactory.setSuccess("修改组织机构成功!");
	}

	/**
	 * @return
	 * @创建时间: 2020年1月29日
	 * @创建人: 许子文
	 * @功能描述: 刷新组织机构缓存
	 */
	public void refreshOrgCache() throws Exception {
		ResponseEntity<Map<String, Object>> orgRet = getOrgTree();

		if (HttpServletResponse.SC_OK == orgRet.getCode()) {
			List<Map<String, Object>> orgTree = orgRet.getRetlist();

			redisUtil.addString(DefineConstant.ORG_CACHE_KEY, JSONObject.toJSONString(orgTree), null);
		}
	}

	/**
	 * @return
	 * @throws Exception
	 * @创建时间: 2020年1月29日
	 * @创建人: 许子文
	 * @功能描述: 刷新菜单数据缓存
	 */
	public void refreshMenuCache() throws Exception {
		ResponseEntity<TreeEntity> menuRet = getMenuTree();

		if (HttpServletResponse.SC_OK == menuRet.getCode()) {
			List<TreeEntity> menuTree = menuRet.getRetlist();

			redisUtil.addString(DefineConstant.MENU_CACHE_KEY, JSONObject.toJSONString(menuTree), null);
		}
	}

	/**
	 * @throws Exception
	 * @创建时间 2020年4月1日
	 * @创建人 许子文
	 * @功能描述: 刷新字典表数据缓存
	 */
	public void refreshDictCache() throws Exception {
		ResponseEntity<Map<Integer, List<DictEntity>>> dictRet = getDictData();

		if (HttpServletResponse.SC_OK == dictRet.getCode()) {
			Map<Integer, List<DictEntity>> dictDatas = dictRet.getRetdata();
			
			Map<String, String> redisHash = installDict2RedisHash(dictDatas);
			
			redisUtil.remove(DefineConstant.DICT_CACHE_KEY);

			redisUtil.addHashValue(DefineConstant.DICT_CACHE_KEY, redisHash, null);
		}

	}
	
	/**
	 * 
	 * @方法名 SystemManageService.java
	 * @创建者 xzw
	 * @创建日期 2021年7月9日
	 * @返回类型 Map<String,String>
	 * @功能描述 组装字典表成redis的hash结构
	 *
	 */
	public Map<String, String> installDict2RedisHash(Map<Integer, List<DictEntity>> dictMap){
		Map<String, String> redisValue = new HashMap<>();
		for (Entry<Integer, List<DictEntity>> entry : dictMap.entrySet()) {
			String pCode = String.valueOf(entry.getKey());
			String dictValue = JSONObject.toJSONString(entry.getValue());
			redisValue.put(pCode, dictValue);
		}
		return redisValue;
	}

	/**
	 * @param word_code
	 * @return
	 * @创建时间 2020年2月17日
	 * @创建人 许子文
	 * @功能描述: 验证词典编码唯一性
	 */
	public ResponseEntity<String> validDictCode(Integer word_code) {

		Integer codeNum;

		try {
			codeNum = systemManageDao.validDictCode(word_code);
		} catch (Exception e) {
			log.error("验证失败", e);
			return ResponseFactory.setFail("验证失败");
		}

		if (codeNum != null && codeNum > 0) {
			return ResponseFactory.setFail("编码重复");
		}

		return ResponseFactory.setSuccess("编码可用");
	}

	/**
	 * @param dictEntity
	 * @return
	 * @创建时间 2020年2月18日
	 * @创建人 许子文
	 * @功能描述: 查询词典数据
	 */
	public ResponseEntity<DictEntity> queryDictList(DictEntity dictEntity) {
		ResponseEntity<DictEntity> ret = new ResponseEntity<>();

		List<DictEntity> dictList = null;

		try {
			dictList = systemManageDao.queryDictList(dictEntity);
		} catch (Exception e) {
			log.error("查询词典数据失败", e);
			return ResponseFactory.setFail("查询词典数据失败");
		}

		return ret.setList(dictList);
	}

	/**
	 * @return
	 * @创建时间 2020年3月8日
	 * @创建人 许子文
	 * @功能描述: 分页查询数据词典
	 */
	public ResponseEntity<PageResponseBean<DictEntity>> queryDictForPage(PageRequestBean<DictEntity> pagerequest) {

		DictEntity dictEntity = pagerequest.getParams();

		int pageNum = pagerequest.getPageNum();
		int pageSize = pagerequest.getPageSize();

		Page<LoginRole> page = PageHelper.startPage(pageNum, pageSize, true);

		List<DictEntity> dicts = null;

		try {
			dicts = systemManageDao.queryDictList(dictEntity);
		} catch (Exception e) {
			log.error("分页查询数据词典失败", e);
			return ResponseFactory.setFail("分页查询数据词典失败");
		}

		long total = page.getTotal();

		int totalPages;

		try {
			totalPages = CommonUtil.getTotalPages(pageSize, total);
		} catch (Exception e) {
			log.error("获取总页数时失败", e);
			return ResponseFactory.setFail("获取总页数时失败");
		}

		PageResponseBean<DictEntity> pageresp = new PageResponseBean<>(total, pageSize, pageNum, totalPages, dicts);

		return ResponseFactory.setObject(pageresp);
	}

	/**
	 * @param dictEntity
	 * @return
	 * @创建时间 2020年3月9日
	 * @创建人 许子文
	 * @功能描述: 添加词典数据
	 */
	public ResponseEntity<String> addDict(DictEntity dictEntity) {

		if (null != dictEntity.getParent_code() && EmptyUtil.isEmpty(dictEntity.getWord_value())) {
			return ResponseFactory.setFail("未输入词值");
		}

		if (null == dictEntity.getParent_code()) {
			dictEntity.setParent_code(0);
		}

		if (EmptyUtil.isEmpty(dictEntity.getWord_code())) {
			return ResponseFactory.setFail("未输入词码");
		}

		if (EmptyUtil.isEmpty(dictEntity.getWord_mean())) {
			return ResponseFactory.setFail("未输入词意");
		}

		try {
			Integer codeNum = systemManageDao.validDictCode(dictEntity.getWord_code());

			if (codeNum != null && codeNum > 0) {
				return ResponseFactory.setFail("词码已存在,请尝试其他值");
			}
		} catch (Exception e) {
			log.error("校验词码重复性失败", e);
			return ResponseFactory.setFail("校验词码重复性失败");
		}

		try {
			systemManageDao.addDict(dictEntity);
		} catch (Exception e) {
			log.error("添加词典数据失败", e);
			return ResponseFactory.setFail("添加词典数据失败");
		}

		try {
			refreshDictCache();
		} catch (Exception e) {
			log.error("刷新词典表缓存失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("刷新词典表缓存失败");
		}

		return ResponseFactory.setSuccess("添加词典数据成功");
	}

	/**
	 * @param word_code
	 * @return
	 * @创建时间 2020年3月9日
	 * @创建人 许子文
	 * @功能描述: 删除词典及子类
	 */
	public ResponseEntity<String> deleteDict(Integer word_code) {

		try {
			systemManageDao.deleteDict(word_code);
		} catch (Exception e) {
			log.error("删除词典数据失败", e);
			return ResponseFactory.setFail("删除词典数据失败");
		}

		try {
			refreshDictCache();
		} catch (Exception e) {
			log.error("刷新词典表缓存失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("刷新词典表缓存失败");
		}

		return ResponseFactory.setSuccess("成功删除词典及其子数据");
	}

	/**
	 * @param dictEntity
	 * @return
	 * @创建事件 2020年3月10日
	 * @创建人 许子文
	 * @功能描述 修改词典数据
	 */
	public ResponseEntity<String> updateDict(DictEntity dictEntity) {

		try {
			systemManageDao.updateDict(dictEntity);
		} catch (Exception e) {
			log.error("修改词典数据失败", e);
			return ResponseFactory.setFail("修改词典数据失败");
		}

		if (EmptyUtil.isEmpty(dictEntity.getParent_code()) && EmptyUtil.isNotEmpty(dictEntity.getWord_code())) {
			try {
				systemManageDao.updateTypeCode(dictEntity);
			} catch (Exception e) {
				log.error("修改子类词典数据的父级编码失败", e);
				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
				return ResponseFactory.setFail("修改子类词典数据的父级编码失败");
			}
		}

		try {
			refreshDictCache();
		} catch (Exception e) {
			log.error("刷新词典表缓存失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return ResponseFactory.setFail("刷新词典表缓存失败");
		}

		return ResponseFactory.setSuccess("成功修改词典数据");
	}

	/**
	 * @return
	 * @创建时间 2020年4月1日
	 * @创建人 许子文
	 * @功能描述: 获取全量的字典数据组成Hash格式的数据
	 */
	public ResponseEntity<Map<Integer, List<DictEntity>>> getDictData() {
		Map<Integer, List<DictEntity>> dictValues = new HashMap<>();

		DictEntity rootParam = new DictEntity();

		rootParam.setRootDict(false);

		List<DictEntity> typeDicts = null;

		try {
			typeDicts = systemManageDao.queryDictList(rootParam);
		} catch (Exception e) {
			log.error("获取字典表的父级类型失败", e);
			return ResponseFactory.setFail("获取字典表的父级类型失败");
		}

		if (EmptyUtil.isEmpty(typeDicts)) {
			log.info("字段表数据为空");
			return ResponseFactory.setFail("字段表数据为空");
		}

		int typeNum = typeDicts.size();

		try {
			for (int i = 0; i < typeNum; i++) {
				DictEntity typedict = typeDicts.get(i);
				Integer parent_code = typedict.getParent_code();
				
				List<DictEntity> childDicts = dictValues.get(parent_code);
				if(null==childDicts) {
					childDicts = new ArrayList<>();
				}
				childDicts.add(typedict);
				dictValues.put(parent_code, childDicts);
			}
		} catch (Exception e) {
			log.error("组装字典表数据结构失败", e);
			return ResponseFactory.setFail("组装字典表数据结构失败");
		}

		return ResponseFactory.setObject(dictValues);
	}
}
